
///////////////////////////////////////////////////////////////////////////////
//
//  Copyright (c) 2009, Perry L. Miller IV
//  All rights reserved.
//  BSD License: http://www.opensource.org/licenses/bsd-license.html
//
///////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////
//
//  For storing the command line.
//
///////////////////////////////////////////////////////////////////////////////

#include "Usul/CommandLine/Arguments.h"
#include "Usul/Threads/Guard.h"

using namespace Usul::CommandLine;


///////////////////////////////////////////////////////////////////////////////
//
//  Typedefs for this file.
//
///////////////////////////////////////////////////////////////////////////////

typedef Usul::Threads::Guard<Arguments::Mutex> Guard;


///////////////////////////////////////////////////////////////////////////////
//
//  Declare the single instance.
//
///////////////////////////////////////////////////////////////////////////////

namespace Usul
{
  namespace CommandLine
  {
    namespace Detail
    {
      Usul::CommandLine::Arguments *_instance ( 0x0 );
    }
  }
}


///////////////////////////////////////////////////////////////////////////////
//
//  Initialize the single instance.
//
///////////////////////////////////////////////////////////////////////////////

namespace
{
  struct Init
  {
    Init()
    {
      Usul::CommandLine::Arguments::instance();
    }
  } _init;
}


///////////////////////////////////////////////////////////////////////////////
//
//  Constructor.
//
///////////////////////////////////////////////////////////////////////////////

Arguments::Arguments() : _args(), _mutex()
{
}


///////////////////////////////////////////////////////////////////////////////
//
//  Destructor.
//
///////////////////////////////////////////////////////////////////////////////

Arguments::~Arguments()
{
}


///////////////////////////////////////////////////////////////////////////////
//
//  Return the single instance.
//
///////////////////////////////////////////////////////////////////////////////

Arguments &Arguments::instance()
{
  if ( 0x0 == Usul::CommandLine::Detail::_instance )
  {
    Usul::CommandLine::Detail::_instance = new Arguments;
  }
  return *(Usul::CommandLine::Detail::_instance);
}


///////////////////////////////////////////////////////////////////////////////
//
//  Get the number of arguments.
//
///////////////////////////////////////////////////////////////////////////////

unsigned int Arguments::size() const
{
  Guard guard ( _mutex );
  return _args.size();
}


///////////////////////////////////////////////////////////////////////////////
//
//  Get the arguments.
//
///////////////////////////////////////////////////////////////////////////////

Arguments::Strings Arguments::get() const
{
  Guard guard ( _mutex );
  return _args;
}


///////////////////////////////////////////////////////////////////////////////
//
//  Return the argument.
//
///////////////////////////////////////////////////////////////////////////////

std::string Arguments::get ( unsigned int index ) const
{
  Guard guard ( _mutex );
  return ( ( index < _args.size() ) ? _args.at ( index ) : std::string() );
}


///////////////////////////////////////////////////////////////////////////////
//
//  Set the arguments.
//
///////////////////////////////////////////////////////////////////////////////

void Arguments::set ( int argc, char **argv )
{
  Guard guard ( _mutex );
  _args.clear();
  if ( ( argc > 0 ) && ( 0x0 != argv ) )
  {
    _args.assign ( argv, argv + argc );
  }
}
